Today, during software development, developers utilize a programming concept called object-oriented programming. In object-oriented programming, computer-readable objects (objects) are defined. The objects have properties and methods. The properties store data that pertains to the object. The methods perform functionality associated with the object and typically, provide interfaces to the properties defined in the object. Even though programming with objects provides great versatility, using objects across remote boundaries, such as between different computers, presents some challenges.
One challenge is determining the mechanism for transferring the objects between the two computers. In certain environments, the executable code (methods) for an object, along with its properties, are transferred to a requesting computer from a server computer. However, this solution may pose a security risk to the requesting computer if the executable code that is transferred performs a malicious action, such as deleting files. Thus, other solutions have been developed to minimize this potential risk.
One current solution is a technology called Web Services Technology. Using this technology, the object is converted into XML (extended mark-up language), which is transmitted to the requesting computer. Upon receiving the XML, the requesting computer converts the XML back into the object. The requesting computer may than access the object's properties and invoke the object's methods. Using this technology, the requesting computer is responsible for knowing and trusting the server from which the object is received. In addition, for any object that wishes to communicate with the requesting computer, the software developer, who developed the object, must implement a special interface to handle the communication. The special interface provides a mechanism for serializing and de-serializing the object in order for the object to be transferred.
Even though this Web Service solution provides a robust environment for transferring objects across remote boundaries, the technology is restrictive and burdensome. In some environments, such as in system administration environments, forcing software developers to implement a special interface for objects that system administration tasks wish to monitor, is not a viable solution. For example, requiring the developers to implement these special interfaces is not a trivial matter, and requires the developers to divert their attention away from their primary objective—implementing the object for their own particular application. Thus, many developers do not implement the special interfaces for their objects, and thus, these objects are not accessible.
Therefore, there is a need for a method of transferring objects across a remote boundary that is secure, not restrictive, and not burdensome to software developers.